import pandas as pd
import numpy as np
import scipy.stats as st
import seaborn as sns
import matplotlib.pyplot as plt

import statsmodels.api as sm
import statsmodels.formula.api as smf
from statsmodels.tsa.stattools import adfuller

from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier, GradientBoostingClassifier, HistGradientBoostingClassifier
from sklearn.svm import SVC, LinearSVC
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from imblearn.over_sampling import RandomOverSampler
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix, f1_score
from sklearn.model_selection import train_test_split
from sklearn.metrics import make_scorer, recall_score

df = pd.read_excel("../Test O_G_Equipment_Data.xlsx")

counts = df["Fail"].value_counts(dropna=False).rename_axis("Fail").reset_index(name="count")
fig, ax = plt.subplots(figsize=(8,6))
bars = ax.bar(counts["Fail"].astype(str), counts["count"])
ax.bar_label(bars, padding=3)
ax.set_title("Count of Fail and Not Fail Events", fontsize=26, pad=20, loc="center")
ax.set_ylim(0, df.shape[0])
fig.subplots_adjust(left=0.15, right=0.95, top=0.85, bottom=0.15)
plt.show()

"{:.2%}".format(df['Fail'].mean())

'8.25%'

def failure_report(data, group):
    data_copy = data.copy()
    total = (data_copy[group].astype(str)
            .value_counts().rename_axis(group)
            .reset_index(name='Number of observations'))
    taxa = (
        data_copy[data_copy["Fail"]][group].astype(str).value_counts() 
        / data_copy[group].astype(str).value_counts()
        ).reset_index(name='Failure percentage')
    base = (total.merge(taxa, on=group, how='left')
                .fillna({'Failure percentage': 0})
                .sort_values(group))
    fig, ax1 = plt.subplots(figsize=(8,6))
    bars = ax1.bar(base[group].astype(str), base['Number of observations'], label='Number of observations')
    ax1.bar_label(bars, padding=3)
    ax1.set_ylabel('Number of observations')
    ax1.set_xlabel(group)
    ax2 = ax1.twinx()
    ax2.plot(base[group].astype(str), base['Failure percentage'], marker='o', linewidth=2, color='red', label='Failure percentage')
    for i, v in enumerate(base['Failure percentage']):
        ax2.text(i, v, f'{v:.1%}', ha='center', va='bottom')
    ax2.set_ylabel('Failure (%)')
    ax1.set_title(f"Number of observations versus Failure percentage\nConsidering {group}", fontsize=26, pad=20)
    ticks = ax2.get_yticks()
    ax2.set_yticklabels([f'{t:.1%}' for t in ticks])
    fig.subplots_adjust(left=0.15, right=0.95, top=0.85, bottom=0.15)
    plt.show()

def heatmap_failure(data):
    data_copy = data.copy()
    matrix_data = (data_copy.groupby(['Preset_1','Preset_2'])['Fail'].mean()
        .mul(100).unstack(fill_value=0).sort_index())
    matrix_data.columns = matrix_data.columns.astype(str)
    matrix_data.index = matrix_data.index.astype(str)
    fig, ax = plt.subplots(figsize=(8,6))
    im = ax.imshow(matrix_data.values, cmap='Reds', aspect='auto')
    ax.set_xticks(range(matrix_data.shape[1]))
    ax.set_xticklabels(matrix_data.columns)
    ax.set_yticks(range(matrix_data.shape[0]))
    ax.set_yticklabels(matrix_data.index)
    for i in range(matrix_data.shape[0]):
        for j in range(matrix_data.shape[1]):
            ax.text(j, i, f"{matrix_data.values[i, j]:.1f}", ha='center', va='center')
    ax.set_xlabel('Preset_2')
    ax.set_ylabel('Preset_1')
    cbar = plt.colorbar(im)
    cbar.set_label('Fail %')
    ax.set_title("Percentage Failure Heatmap\nCombining Preset_1 and Preset_2", fontsize=26, pad=20)
    fig.subplots_adjust(left=0.15, right=0.95, top=0.85, bottom=0.15)
    plt.show()

def heatmap_configuration_changes(data, group):
    data_copy = data.copy()
    data_copy[f'Previous {group}'] = data_copy[group].shift()
    data_copy = data_copy.dropna()
    data_copy[f'Previous {group}'] = data_copy[f'Previous {group}'].astype(int)
    data_copy[f'Previous {group}'] = data_copy[f'Previous {group}'].astype(str)
    data_copy[group] = data_copy[group].astype(str)
    n_changes_df = (
        data_copy
        [[f'Previous {group}', group]]
        .value_counts()
        .reset_index(name="Number of Changes")
    )
    n_changes_df["Percent of changes during operation"] = n_changes_df["Number of Changes"] / data_copy.shape[0]
    n_changes_df = (
        n_changes_df
        .rename(columns={
            f'Previous {group}':"From",
            group:"To"
            }
        )
        .sort_values(by=["From", "To"])
        .reset_index(drop=True)
    )
    order_x = sorted(n_changes_df["From"].unique())
    order_y = sorted(n_changes_df["To"].unique())
    fig, ax = plt.subplots(figsize=(8,6))
    z = np.zeros((len(order_y), len(order_x)))
    for i, y in enumerate(order_y):
        for j, x in enumerate(order_x):
            v = n_changes_df.loc[(n_changes_df["From"]==x) & (n_changes_df["To"]==y), "Percent of changes during operation"].values
            z[i, j] = v[0] if len(v) else 0
    vmax = z.max() if z.max() > 0 else 1
    vmin = z[z>0].min() if np.any(z>0) else 0
    im = ax.imshow(z, cmap="Reds", aspect="auto", vmin=vmin, vmax=vmax)
    ax.set_xticks(range(len(order_x)))
    ax.set_xticklabels(order_x)
    ax.set_yticks(range(len(order_y)))
    ax.set_yticklabels(order_y)
    for i in range(len(order_y)):
        for j in range(len(order_x)):
            ax.text(j, i, f"{z[i,j]:.2%}", ha="center", va="center")
    ticks = np.linspace(vmin, vmax, 6)
    cbar = plt.colorbar(im, ticks=ticks)
    cbar.set_ticklabels([f"{t:.0%}" for t in ticks])
    cbar.set_label("Percent of changes during operation")
    ax.set_title(f"Percent of changes from {group} configurations during operation", fontsize=26, pad=20)
    fig.subplots_adjust(left=0.15, right=0.95, top=0.85, bottom=0.15)
    if n_changes_df.shape[0] > 200:
        fig.set_figheight(9)
        fig.set_figwidth(20)
    plt.show()




def boxplots(data, group, variable):
    data_copy = data.copy()
    model = smf.ols(f'{variable} ~ C({group})', data=data_copy).fit()
    resid = model.resid
    fitted = model.fittedvalues
    fig = st.probplot(resid, dist="norm", plot=plt)
    plt.title(f"QQ plot of residuals - {variable} ~ C({group})")
    plt.show()
    plt.scatter(fitted, resid, s=8, alpha=0.6)
    plt.axhline(0, lw=1, color='k')
    plt.xlabel("Fitted values")
    plt.ylabel("Residuals")
    plt.title(f"Residuals vs Fitted - {variable} ~ C({group})")
    plt.show()
    fig, ax = plt.subplots()
    data_copy.boxplot(column=variable, by=group, ax=ax)
    ax.set_xlabel(group)
    ax.set_ylabel(variable)
    plt.suptitle("")
    plt.xticks(rotation=45)
    fig.subplots_adjust(top=0.85, bottom=0.2)
    model = smf.ols(f'{variable} ~ C({group})', data=data_copy).fit()
    anova_tbl = sm.stats.anova_lm(model, typ=2)
    df1 = float(anova_tbl.loc[f'C({group})', 'df'])
    df2 = float(anova_tbl.loc['Residual', 'df'])
    Fval = float(anova_tbl.loc[f'C({group})', 'F'])
    pval = float(anova_tbl.loc[f'C({group})', 'PR(>F)'])
    ss_effect = float(anova_tbl.loc[f'C({group})', 'sum_sq'])
    ss_error  = float(anova_tbl.loc['Residual', 'sum_sq'])
    mse = ss_error / df2
    y = data_copy[variable].to_numpy(dtype=float)
    ss_total = float(((y - y.mean())**2).sum())
    eta2   = ss_effect / ss_total
    omega2 = (ss_effect - df1 * mse) / (ss_total + mse)
    k = data_copy[group].nunique()
    N = len(data_copy)
    text_ = (
        f"ANOVA (one-way) — {variable} ~ {group}\n"
        f"F({int(df1)}, {int(df2)}) = {Fval:.2f}, p = {pval:.3g} "
        f"| η² = {eta2:.3f}, ω² = {omega2:.3f} "
        f"| k = {k}, N = {N}"
    )
    fig.text(0.0, 0.98, text_, ha='left', va='top', bbox=dict(facecolor='white', alpha=0.75, edgecolor='black', linewidth=1))
    plt.show()

failure_report(df, "Preset_1")
failure_report(df, "Preset_2")

aux_data = df.copy()
aux_data["Preset_1_2"] = df['Preset_1'].astype(str) + df['Preset_2'].astype(str)

failure_report(aux_data, "Preset_1_2")

/tmp/ipykernel_28877/1418244333.py:25: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  ax2.set_yticklabels([f'{t:.1%}' for t in ticks])

/tmp/ipykernel_28877/1418244333.py:25: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  ax2.set_yticklabels([f'{t:.1%}' for t in ticks])

/tmp/ipykernel_28877/1418244333.py:25: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  ax2.set_yticklabels([f'{t:.1%}' for t in ticks])

heatmap_failure(df)

heatmap_configuration_changes(df, "Preset_1")
heatmap_configuration_changes(df, "Preset_2")

aux_data = df.copy()
aux_data["Preset_1_2"] = df['Preset_1'].astype(str) + df['Preset_2'].astype(str)

heatmap_configuration_changes(aux_data, "Preset_1_2")

for column in df.columns[3:-1]:
    boxplots(df, 'Preset_1', column)

for column in df.columns[3:-1]:
    boxplots(df, 'Preset_2', column)

aux = df.copy()
aux['Preset_1_2'] = aux['Preset_1'].astype(str) + '-' + aux['Preset_2'].astype(str)
for column in df.columns[3:-1]:
    boxplots(aux, 'Preset_1_2', column)

def cycles_per_variable(data, x_axis, variable):
    data_copy = data.copy()
    data_copy[variable].quantile(0.95)
    data_copy[variable].quantile(0.05)
    p05 = data_copy[variable].quantile(0.05)
    p95 = data_copy[variable].quantile(0.95)
    median = data_copy[variable].median()
    df_sorted = data_copy.sort_values([x_axis])
    fig, ax = plt.subplots(figsize=(8,6))
    ax.plot(df_sorted[x_axis], df_sorted[variable], color="red", linewidth=2, label=variable)
    ax.fill_between(df_sorted[x_axis], p05, p95, alpha=0.2, label='P05–P95')
    ax.axhline(median, linestyle='--', linewidth=2, color='blue', label='Median')
    ax.axhline(p95, linestyle=':', linewidth=1)
    ax.axhline(p05, linestyle=':', linewidth=1)
    for x in data_copy.loc[data_copy["Fail"], x_axis].unique():
        ax.axvline(x=x, linewidth=2, color="black", alpha=0.5)
    ax.plot([], [], color="black", alpha=0.5, linewidth=1, label="Failure events")
    ax.set_ylim(0, 1.1 * data_copy[variable].max())
    ax.set_title(f"{variable} per {x_axis} with Failure events", fontsize=26, pad=20)
    ax.set_xlabel(x_axis)
    ax.set_ylabel(variable)
    ax.legend()
    fig.subplots_adjust(left=0.15, right=0.95, top=0.85, bottom=0.15)
    plt.show()

def failure_3d_plot(data, x_value, y_value, z_value):
    data_copy = data.copy()
    fig = plt.figure(figsize=(8,6))
    ax = fig.add_subplot(111, projection='3d')
    d_true = data_copy[data_copy["Fail"]==True]
    d_false = data_copy[data_copy["Fail"]==False]
    ax.scatter(d_true[x_value], d_true[y_value], d_true[z_value], c="black", s=3, label="True")
    ax.scatter(d_false[x_value], d_false[y_value], d_false[z_value], c="lightgray", s=3, label="False")
    ax.set_title(f"3d Plot {x_value} versus {y_value} versus {z_value} per Failure event", fontsize=26, pad=20)
    ax.set_xlabel(x_value)
    ax.set_ylabel(y_value)
    ax.set_zlabel(z_value)
    ax.legend(title="Fail")
    fig.subplots_adjust(left=0.0, right=1.0, top=0.9, bottom=0.0)
    plt.show()

def failure_2d_plot(data, x_value, y_value):
    data_copy = data.copy()
    fig, ax = plt.subplots(figsize=(8,6))
    d_true = data_copy[data_copy["Fail"]==True]
    d_false = data_copy[data_copy["Fail"]==False]
    ax.scatter(d_true[x_value], d_true[y_value], c="black", s=20, label="True")
    ax.scatter(d_false[x_value], d_false[y_value], c="lightgray", s=20, label="False")
    ax.set_title(f"Scatter Plot {x_value} versus {y_value} per Failure event", fontsize=26, pad=20)
    ax.set_xlabel(x_value)
    ax.set_ylabel(y_value)
    ax.legend(title="Fail")
    fig.subplots_adjust(left=0.15, right=0.95, top=0.85, bottom=0.15)
    plt.show()

for column in df.columns[3:-1]:
    cycles_per_variable(df, "Cycle", column)

aux_data = df.copy()

aux_data["Module Vibration"] = aux_data.apply(lambda x: ((x["VibrationX"]**2) + (x["VibrationY"]**2) + (x["VibrationZ"]**2))**(1/2), axis=1)

cycles_per_variable(aux_data, "Cycle", "Module Vibration")

failure_2d_plot(df, "Temperature", "Pressure")

failure_2d_plot(aux_data, "Module Vibration", "Frequency")

failure_2d_plot(aux_data, "Module Vibration", "Temperature")

failure_2d_plot(aux_data, "Module Vibration", "Pressure")

failure_3d_plot(df, "Temperature", "Pressure", "Frequency")

failure_3d_plot(df, "VibrationX", "VibrationY", "VibrationZ")

def test_stationarity(series, scope):

    print(f'Dickey-Fuller (Dataset {scope}):')
    adf_test = adfuller(series.dropna())

    adf_stat = adf_test[0]
    p_value = adf_test[1]
    critical_values = adf_test[4]


    print(f'ADF statistic: {adf_stat}')
    print(f'p-value: {p_value}')
    print('Critical values:')
    for key, value in critical_values.items():
        print(f'\t{key}: {value}')


    if adf_stat < critical_values['5%']:
        print("The series is stationary (Reject the null hypothesis)")
    else:
        print("The series is NOT stationary (Fail to reject the null hypothesis)")


numerical_features = ["Temperature", "Pressure", "VibrationX", "VibrationY", "VibrationZ", "Frequency"]
for col in numerical_features:
    s = df.sort_values('Cycle')[col]
    test_stationarity(s, col)

Dickey-Fuller (Dataset Temperature):
ADF statistic: -12.988680950011224
p-value: 2.8425779537946296e-24
Critical values:
	1%: -3.438581476199162
	5%: -2.865173218890781
	10%: -2.56870466056054
The series is stationary (Reject the null hypothesis)
Dickey-Fuller (Dataset Pressure):
ADF statistic: -8.973295804703648
p-value: 7.6502921761507e-15
Critical values:
	1%: -3.438602251755426
	5%: -2.8651823762743245
	10%: -2.5687095387840673
The series is stationary (Reject the null hypothesis)
Dickey-Fuller (Dataset VibrationX):
ADF statistic: -6.9958169063199565
p-value: 7.538878106337241e-10
Critical values:
	1%: -3.438623132449471
	5%: -2.8651915799370014
	10%: -2.568714441670417
The series is stationary (Reject the null hypothesis)
Dickey-Fuller (Dataset VibrationY):
ADF statistic: -8.009749176554534
p-value: 2.2177469565403674e-12
Critical values:
	1%: -3.438602251755426
	5%: -2.8651823762743245
	10%: -2.5687095387840673
The series is stationary (Reject the null hypothesis)
Dickey-Fuller (Dataset VibrationZ):
ADF statistic: -6.648510831277863
p-value: 5.191805426666831e-09
Critical values:
	1%: -3.438633612472885
	5%: -2.865196199232788
	10%: -2.5687169024206713
The series is stationary (Reject the null hypothesis)
Dickey-Fuller (Dataset Frequency):
ADF statistic: -9.59674762354758
p-value: 1.9690415765210325e-16
Critical values:
	1%: -3.438602251755426
	5%: -2.8651823762743245
	10%: -2.5687095387840673
The series is stationary (Reject the null hypothesis)

def kde(df, numerical_columns, target_col):

    num_cols = len(numerical_columns)
    plt.figure(figsize=(18, 15))

    for i, column in enumerate(numerical_columns):
        plt.subplot(num_cols, 2, 2*i+1)
        sns.kdeplot(data=df, x=column, hue=target_col, fill=True)
        plt.title(f'KDE distribution of {column} by {target_col}')


    plt.tight_layout()
    plt.show()

numerical_features = ["Temperature", "Pressure", "VibrationX", "VibrationY", "VibrationZ", "Frequency"]

kde(df, numerical_features, 'Fail')

def plot_correlation_heatmap(df,features):
    corr_matrix = df[features].corr()

    plt.figure(figsize=(8, 3))

    sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', fmt='.2f', linewidths=0.5)

    plt.title('Heatmap of numerical features correlation')
    plt.show()

plot_correlation_heatmap(df,numerical_features)

def preprocess(data,drops, columns, target):
  data_copy = data.copy()
  y = data_copy[target]
  X = data_copy.drop(drops, axis=1)

  scaler = StandardScaler()
  X[columns] = scaler.fit_transform(X[columns])

  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
  return  X_train, X_test, y_train, y_test

def train_model(X_train, y_train, model_exp):

    scorer = make_scorer(recall_score, pos_label=1)

    if model_exp == 'Random Forest':
        model = RandomForestClassifier(random_state=42)
        param_grid = {
            'n_estimators': [100, 200, 300],
            'max_depth': [10, 20, None],
            'min_samples_split': [2, 5, 10]
        }

    elif model_exp == 'SVM':
        model = SVC(kernel='rbf', random_state=42)
        param_grid = {
            'C': [0.1, 1, 10],
            'gamma': ['scale', 'auto'],
            'kernel': ['rbf']
        }

    elif model_exp == 'Logistic Regression':
        model = LogisticRegression(max_iter=1000, solver='saga', n_jobs=-1)
        param_grid = {
            'C': [0.01, 0.1, 1, 10],
            'penalty': ['l1', 'l2']
        }

    elif model_exp == 'Extra Trees':
        model = ExtraTreesClassifier(random_state=42, n_jobs=-1)
        param_grid = {
            'n_estimators': [200, 400],
            'max_depth': [None, 10, 20],
            'min_samples_split': [2, 10]
        }

    elif model_exp == 'Gradient Boosting':
        model = GradientBoostingClassifier(random_state=42)
        param_grid = {
            'n_estimators': [100, 300],
            'learning_rate': [0.05, 0.1],
            'max_depth': [2, 3]
        }

    elif model_exp == 'HistGB':
        model = HistGradientBoostingClassifier(random_state=42)
        param_grid = {
            'max_depth': [None, 6, 12],
            'learning_rate': [0.05, 0.1],
            'max_leaf_nodes': [31, 63]
        }

    elif model_exp == 'KNN':
        model = KNeighborsClassifier()
        param_grid = {
            'n_neighbors': [5, 15, 30],
            'weights': ['uniform', 'distance'],
            'p': [1, 2]
        }

    elif model_exp == 'Linear SVM':
        model = LinearSVC(random_state=42)
        param_grid = {
            'C': [0.1, 1, 10]
        }

    grid_search = GridSearchCV(estimator=model, param_grid=param_grid,
                               scoring=scorer, cv=5, n_jobs=-1, verbose=2)
    grid_search.fit(X_train, y_train)

    print(f"Better parameters for {model_exp}: {grid_search.best_params_}")
    return grid_search.best_estimator_


def predict_and_evaluate(model, X_test, y_test):

  y_pred = model.predict(X_test)
  conf_matrix = confusion_matrix(y_test, y_pred)
  sns.heatmap(conf_matrix, annot=True, fmt='d')
  plt.title('Confusion Matrix')
  plt.show()
  print(f'Model: {model}')
  print(classification_report(y_test, y_pred))

  f1 = f1_score(y_test, y_pred)
  print(f'F1 score: {f1 * 100:.2f}%')

df["Preset_1"] = df["Preset_1"].astype(str)
df["Preset_2"] = df["Preset_2"].astype(str)
df_hot = pd.get_dummies(df, columns=["Preset_1", "Preset_2"], drop_first=False)

models = ['Random Forest', 'SVM', 'Logistic Regression', 'Extra Trees', 'Gradient Boosting', 'HistGB', 'KNN', 'Linear SVM']
aux = df.copy()
aux["Fail"] = aux["Fail"].apply(lambda x: 1 if x else 0)
drops = ["Preset_1",  "Preset_2", "Fail", "Cycle"]
X_train, X_test, y_train, y_test = preprocess(aux, drops, numerical_features, "Fail")
ros = RandomOverSampler(sampling_strategy=0.5, random_state=42)
X_train_ros, y_train_ros = ros.fit_resample(X_train, y_train)
X_train_hot, X_test_hot, y_train_hot, y_test_hot = preprocess(df_hot, ["Fail", "Cycle"], numerical_features, "Fail")
X_train_hot_ros, y_train_hot_ros = ros.fit_resample(X_train_hot, y_train_hot)

for model in models:
  print('-------------------------------------------------------------------------------')
  print('-------------------------- Original dataset -----------------------------------')
  print(f'Model: {model}')
  print('-------------------------------------------------------------------------------')
  tmodel = train_model(X_train, y_train, model)
  predict_and_evaluate(tmodel, X_test, y_test)
  print('-------------------------------------------------------------------------------')
  print('-------------------------- Random oversampled ---------------------------------')
  print(f'Model: {model}')
  print('-------------------------------------------------------------------------------')
  tmodel = train_model(X_train_ros, y_train_ros, model)
  predict_and_evaluate(tmodel, X_test, y_test)
  print('-------------------------------------------------------------------------------')
  print('-------------------------- Original dataset one hot encoded -------------------')
  print(f'Model: {model}')
  print('-------------------------------------------------------------------------------')
  tmodel = train_model(X_train_hot, y_train_hot, model)
  predict_and_evaluate(tmodel, X_test_hot, y_test_hot)
  print('-------------------------------------------------------------------------------')
  print('-------------------------- Random oversampled one hot encoded -----------------')
  print(f'Model: {model}')
  print('-------------------------------------------------------------------------------')
  tmodel = train_model(X_train_hot_ros, y_train_hot_ros, model)
  predict_and_evaluate(tmodel, X_test_hot, y_test_hot)
  print('-------------------------------------------------------------------------------')

-------------------------------------------------------------------------------
-------------------------- Original dataset -----------------------------------
Model: Random Forest
-------------------------------------------------------------------------------
Fitting 5 folds for each of 27 candidates, totalling 135 fits

Better parameters for Random Forest: {'max_depth': 10, 'min_samples_split': 2, 'n_estimators': 200}

Model: RandomForestClassifier(max_depth=10, n_estimators=200, random_state=42)
              precision    recall  f1-score   support

           0       0.97      0.99      0.98       225
           1       0.70      0.47      0.56        15

    accuracy                           0.95       240
   macro avg       0.83      0.73      0.77       240
weighted avg       0.95      0.95      0.95       240

F1 score: 56.00%
-------------------------------------------------------------------------------
-------------------------- Random oversampled ---------------------------------
Model: Random Forest
-------------------------------------------------------------------------------
Fitting 5 folds for each of 27 candidates, totalling 135 fits

Better parameters for Random Forest: {'max_depth': 10, 'min_samples_split': 2, 'n_estimators': 100}

Model: RandomForestClassifier(max_depth=10, random_state=42)
              precision    recall  f1-score   support

           0       0.98      0.97      0.97       225
           1       0.59      0.67      0.62        15

    accuracy                           0.95       240
   macro avg       0.78      0.82      0.80       240
weighted avg       0.95      0.95      0.95       240

F1 score: 62.50%
-------------------------------------------------------------------------------
-------------------------- Original dataset one hot encoded -------------------
Model: Random Forest
-------------------------------------------------------------------------------
Fitting 5 folds for each of 27 candidates, totalling 135 fits

Better parameters for Random Forest: {'max_depth': 10, 'min_samples_split': 2, 'n_estimators': 100}

Model: RandomForestClassifier(max_depth=10, random_state=42)
              precision    recall  f1-score   support

       False       0.97      0.99      0.98       225
        True       0.78      0.47      0.58        15

    accuracy                           0.96       240
   macro avg       0.87      0.73      0.78       240
weighted avg       0.95      0.96      0.95       240

F1 score: 58.33%
-------------------------------------------------------------------------------
-------------------------- Random oversampled one hot encoded -----------------
Model: Random Forest
-------------------------------------------------------------------------------
Fitting 5 folds for each of 27 candidates, totalling 135 fits

Better parameters for Random Forest: {'max_depth': 10, 'min_samples_split': 2, 'n_estimators': 100}

Model: RandomForestClassifier(max_depth=10, random_state=42)
              precision    recall  f1-score   support

       False       0.97      0.98      0.97       225
        True       0.62      0.53      0.57        15

    accuracy                           0.95       240
   macro avg       0.79      0.76      0.77       240
weighted avg       0.95      0.95      0.95       240

F1 score: 57.14%
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------- Original dataset -----------------------------------
Model: SVM
-------------------------------------------------------------------------------
Fitting 5 folds for each of 6 candidates, totalling 30 fits
Better parameters for SVM: {'C': 10, 'gamma': 'scale', 'kernel': 'rbf'}

Model: SVC(C=10, random_state=42)
              precision    recall  f1-score   support

           0       0.99      0.97      0.98       225
           1       0.63      0.80      0.71        15

    accuracy                           0.96       240
   macro avg       0.81      0.88      0.84       240
weighted avg       0.96      0.96      0.96       240

F1 score: 70.59%
-------------------------------------------------------------------------------
-------------------------- Random oversampled ---------------------------------
Model: SVM
-------------------------------------------------------------------------------
Fitting 5 folds for each of 6 candidates, totalling 30 fits

model = "SVM"

print('-------------------------- Original dataset -----------------------------------')
print(f'Model: {model}')
print('-------------------------------------------------------------------------------')
X_train, X_test, y_train, y_test = preprocess(aux, drops, numerical_features, "Fail")
tmodel = train_model(X_train, y_train, model)
predict_and_evaluate(tmodel, X_test, y_test)

-------------------------- Original dataset -----------------------------------
Model: SVM
-------------------------------------------------------------------------------
Fitting 5 folds for each of 6 candidates, totalling 30 fits

Better parameters for SVM: {'C': 10, 'gamma': 'scale', 'kernel': 'rbf'}

Model: SVC(C=10, random_state=42)
              precision    recall  f1-score   support

           0       0.99      0.97      0.98       225
           1       0.63      0.80      0.71        15

    accuracy                           0.96       240
   macro avg       0.81      0.88      0.84       240
weighted avg       0.96      0.96      0.96       240

F1 score: 70.59%

X_train, X_test, y_train, y_test = preprocess(aux, drops, numerical_features, "Fail")

tmodel = RandomForestClassifier(max_depth=10, min_samples_split=10, 
                                n_estimators=300, random_state=42)

tmodel.fit(X_train, y_train)

predict_and_evaluate(tmodel, X_test, y_test)

def plot_feature_importance(model, X_train):

    importances = model.feature_importances_

    feature_names = X_train.columns

    feature_importance_df = pd.DataFrame({
        'Feature': feature_names,
        'Importance': importances
    }).sort_values(by='Importance', ascending=False)

    plt.figure(figsize=(10, 6))
    plt.barh(feature_importance_df['Feature'], feature_importance_df['Importance'], color='royalblue')
    plt.xlabel('Importance')
    plt.ylabel('Feature')
    plt.title('Feature importance - Random Forest')
    plt.gca().invert_yaxis()
    plt.show()

plot_feature_importance(tmodel, X_train)

Model: RandomForestClassifier(max_depth=10, min_samples_split=10, n_estimators=300,
                       random_state=42)
              precision    recall  f1-score   support

           0       0.97      0.98      0.97       225
           1       0.64      0.47      0.54        15

    accuracy                           0.95       240
   macro avg       0.80      0.72      0.76       240
weighted avg       0.94      0.95      0.95       240

F1 score: 53.85%

Major task¶

Task 1¶

Task 2¶

Evaluating Presets regarding Number of obsertations and Failure percentage¶

Presets Failure Percentage Heatmap¶

Presets state changes during operation¶

Boxplots per presets during operation¶

Task 3¶

Task 4¶

Model choice¶

Task 5¶